.TH std::end,std::cend 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::end,std::cend \- std::end,std::cend

.SH Synopsis
   Defined in header <array>
   Defined in header <deque>
   Defined in header <flat_map>
   Defined in header <flat_set>
   Defined in header <forward_list>
   Defined in header <iterator>
   Defined in header <list>
   Defined in header <map>
   Defined in header <regex>
   Defined in header <set>
   Defined in header <span>
   Defined in header <string>
   Defined in header <string_view>
   Defined in header <unordered_map>
   Defined in header <unordered_set>
   Defined in header <vector>
   template< class C >                                   \fI(since C++11)\fP
   auto end( C& c ) -> decltype(c.end());            \fB(1)\fP (constexpr since
                                                         C++17)
   template< class C >                                   \fI(since C++11)\fP
   auto end( const C& c ) -> decltype(c.end());      \fB(2)\fP (constexpr since
                                                         C++17)
   template< class T, std::size_t N >                                     \fI(since C++11)\fP
   T* end( T (&array)[N] );                                               \fI(until C++14)\fP
   template< class T, std::size_t N >                                     \fI(since C++14)\fP
   constexpr T* end( T (&array)[N] ) noexcept;
   template< class C >                               \fB(3)\fP

   constexpr auto cend( const C& c ) noexcept(/* see     \fB(4)\fP              \fI(since C++14)\fP
   below */)

       -> decltype(std::end(c));

   Returns an iterator to the end (i.e. the element after the last element) of the
   given range.

   1,2) Returns c.end(), which is typically an iterator one past the end of the
   sequence represented by c.
   1) If C is a standard Container, returns a C::iterator object.
   2) If C is a standard Container, returns a C::const_iterator object.
   3) Returns a pointer to the end of array.
   4) Returns std::end(c), with c always treated as const-qualified.
   If C is a standard Container, returns a C::const_iterator object.

   range-begin-end.svg

.SH Parameters

   c     - a container or view with an end member function
   array - an array of arbitrary type

.SH Return value

   1,2) c.end()
   3) array + N
   4) c.end()

.SH Exceptions

   4)
   noexcept specification:
   noexcept(noexcept(std::end(c)))

   Overloads

   Custom overloads of end may be provided for classes and enumerations that do not
   expose a suitable end() member function, yet can be iterated. The following
   overloads are already provided by the standard library:

   std::end(std::initializer_list)                      specializes std::end
   \fI(C++11)\fP                                              \fI(function template)\fP
   std::end(std::valarray)                              specializes std::end
   \fI(C++11)\fP                                              \fI(function template)\fP
   begin(std::filesystem::directory_iterator)           range-based for loop support
   end(std::filesystem::directory_iterator)             \fI(function)\fP
   \fI(C++17)\fP
   begin(std::filesystem::recursive_directory_iterator) range-based for loop support
   end(std::filesystem::recursive_directory_iterator)   \fI(function)\fP

   Similar to the use of swap (described in Swappable), typical use of the end function
   in generic context is an equivalent of using std::end; end(arg);, which lets both
   the ADL-selected overloads for user-defined types and the standard library function
   templates to appear in the same overload set.

 template<typename Container, typename Function>
 void for_each(Container&& cont, Function f)
 {
     using std::begin;
     auto it = begin(cont);
     using std::end;
     auto end_it = end(cont);

     for (; it != end_it; ++it)
         f(*it);
 }

   Overloads of end found by argument-dependent lookup can be used to
   customize the behavior of std::ranges::end, std::ranges::cend, and     \fI(since C++20)\fP
   other customization pointer objects depending on std::ranges::end.

.SH Notes

   The non-array overloads exactly reflect the behavior of C::end(). Their effects may
   be surprising if the member function does not have a reasonable implementation.

   std::cend is introduced for unification of member and non-member range accesses. See
   also LWG issue 2128.

   If C is a shallow-const view, std::cend may return a mutable iterator. Such behavior
   is unexpected for some users. See also P2276 and P2278.

.SH Example


// Run this code

 #include <algorithm>
 #include <iostream>
 #include <vector>

 int main()
 {
     std::vector<int> v = {3, 1, 4};
     if (std::find(std::begin(v), std::end(v), 5) != std::end(v))
         std::cout << "Found a 5 in vector v!\\n";

     int w[] = {5, 10, 15};
     if (std::find(std::begin(w), std::end(w), 5) != std::end(w))
         std::cout << "Found a 5 in array w!\\n";
 }

.SH Output:

 Found a 5 in array w!

.SH See also

   begin
   cbegin       returns an iterator to the beginning of a container or array
   \fI(C++11)\fP      \fI(function template)\fP
   \fI(C++14)\fP
   ranges::end  returns a sentinel indicating the end of a range
   (C++20)      (customization point object)
   ranges::cend returns a sentinel indicating the end of a read-only range
   (C++20)      (customization point object)

.SH Category:
     * conditionally noexcept
